home *** CD-ROM | disk | FTP | other *** search
/ Collection of Tools & Utilities / Collection of Tools and Utilities.iso / c / mc302emb.zip / LIBCF / LONGMATH.ASM < prev    next >
Assembly Source File  |  1994-03-18  |  5KB  |  238 lines
  1. *
  2. * Long math functions
  3. *
  4. ?LSIZE    EQU    4        4 bytes (32 bits)
  5. $DD:Longreg 4
  6. * Add two long numbers: longadd(num1, num2)
  7. longadd    LDB    #?LSIZE        Get size
  8.     PUSHA            Save for later
  9. ?1    LDI    4,S        Get num2 ptr
  10.     LDB    I        Get byte
  11.     LEAI    1,I        Skip to next
  12.     STI    4,S        Resave
  13.     LDI    6,S        Get num1 pointer
  14.     ADDB    I        Add in low
  15.     ADDB    1,S        Include carry
  16.     STB    I        Resave
  17.     LEAI    1,I        Skip to next
  18.     STI    6,S        Resave
  19.     SHR    #8        Keep carry out
  20.     STB    1,S        Set new carry out
  21.     LDB    ,S        Get count
  22.     DEC            Reduce
  23.     STB    ,S        Resave
  24.     JNZ    ?1        Do them all
  25.     LD    S+        Restore value
  26.     SHR    #8        Return carry out
  27.     RET
  28. * Subtract two long numbers: longsub(num1, num2)
  29. longsub    LDB    #?LSIZE        Get size
  30.     PUSHA            Save for later
  31. ?2    LDI    6,S        Get num1 pointer
  32.     LDB    I        Get value
  33.     LDI    4,S        Get num2 pointer
  34.     SUBB    I        Subtract
  35.     LEAI    1,I        Skip
  36.     STI    4,S        Resave
  37.     SUBB    1,S        Include borrow
  38.     LDI    6,S        Get num1 back
  39.     STB    I        Resave
  40.     LEAI    1,I        Skip
  41.     STI    6,S        Resave
  42.     SHR    #8        Retain borrow
  43.     NOT            Convert to 0/1
  44.     NOT            Convert to 1/0
  45.     STB    1,S        Set new borrow
  46.     LDB    ,S        Get count
  47.     DEC            Reduce
  48.     STB    ,S        Resave
  49.     JNZ    ?2        Do them all
  50.     LD    S+        Restore value
  51.     SHR    #8        Return carry out
  52.     RET
  53. * Shift a long number RIGHT: longshr(num1)
  54. longshr    LDB    #?LSIZE        Get long size
  55.     PUSHA            Save for later
  56. ?3    DEC            Backup
  57.     STB    ,S        Resave count
  58.     ADD    4,S        Get pointer to position
  59.     TAI            Set index
  60.     LDB    I        Get value
  61.     PUSHA            Save old value
  62.     SHR    #1        Shift one bit
  63.     ORB    3,S        Include carry
  64.     STB    I        Resave
  65.     LD    S+        Get carry
  66.     ANDB    #%00000001    Get old carry out
  67.     SHL    #7        Convert to 80 : 0
  68.     STB    1,S        Save new carry
  69.     LDB    ,S        Get count
  70.     JNZ    ?3        Do them all
  71.     LD    S+        Restore value
  72.     NOT            Convert to 0/1
  73.     NOT            Convert to 1/0
  74.     RET
  75. * Shift a long number LEFT: longshl(num1)
  76. longshl    LDI    2,S        Get pointer to num1
  77.     LDB    #?LSIZE        Get long size
  78.     PUSHA            Save for later
  79. ?4    LDB    I        Get old value
  80.     SHL    #1        Shift left
  81.     ORB    1,S        Include old shift out
  82.     STB    I        Resave
  83.     SHR    #8        Keep carry out
  84.     STB    1,S        Save new carry out
  85.     LEAI    1,I        Advance to next
  86.     LDB    ,S        Get count
  87.     DEC            Reduce
  88.     STB    ,S        Resave
  89.     JNZ    ?4        Do them all
  90.     LD    S+        Restore value
  91.     SHR    #8        Return carry out
  92.     RET
  93. * Test a long number for zero: longtst(num1)
  94. longtst    LDI    2,S        Get pointer to num1
  95. ?50    LDB    #?LSIZE        Get count
  96. ?5    PUSHA            Save count
  97.     LDB    I        Get value
  98.     SJNZ    ?6        Not-z, exit
  99.     LEAI    1,I        Skip to next
  100.     LD    S+        Get value
  101.     DEC            Backup
  102.     SJNZ    ?5        Do them all
  103.     RET
  104. ?6    LDI    S+        Clean stack
  105.     RET
  106. * Compare two long numbers
  107. longcmp    LDB    #?LSIZE        Get count
  108. ?7    PUSHA            Save for later
  109.     DEC            Backup
  110.     STB    ,S        Resave
  111.     LDI    6,S        Get num1 pointer
  112.     ADAI            Offset to char
  113.     ADD    4,S        Offset to num2
  114.     PUSHA            Save for later
  115.     LDB    I        Get num1 byte
  116.     CMPB    [S+]        Compare with num2
  117.     SJZ    ?9        Not same, exit
  118.     LD    S+        Get count
  119.     SJNZ    ?7        Do them all
  120. ?8    RET
  121. ?9    UGT            Test for less
  122.     SJNZ    ?91        Greater, return 1
  123.     COM            Get -1
  124. ?91    LDI    S+        Clean stack
  125.     RET
  126. * Zero temporary register
  127. ?10    LDI    #Longreg    Point to it
  128. ?11    LDB    #?LSIZE        Get length
  129. ?12    PUSHA            Save it
  130.     CLR            Get zero
  131.     STB    I        Save it
  132.     LEAI    1,I        Advance
  133.     LD    S+        Get value
  134.     DEC            Backup
  135.     SJNZ    ?12        Do em all
  136.     RET
  137. * Set a LONG number to value: longset(num1, value)
  138. longset    LDI    4,S        Get pointer
  139.     CALL    ?11        Zero it
  140.     LDI    4,S        Get pointer
  141.     LD    2,S        Get value
  142.     ST    I        Write it
  143.     RET
  144. * Copy a LONG number: longcpy(dest, source)
  145. longcpy    LDB    #?LSIZE        Get size
  146. ?13    PUSHA            Save it
  147.     LDI    4,S        Get source
  148.     LDB    I        Get byte
  149.     LEAI    1,I        Advance
  150.     STI    4,S        Resave
  151.     LDI    6,S        Get dest
  152.     STB    I        Write value
  153.     LEAI    1,I        Advance
  154.     STI    6,S        Resave
  155.     LD    S+        Get count
  156.     DEC            Reduce
  157.     SJNZ    ?13        Do all
  158.     RET
  159. * Multiply two LONG numbers: longmul(num1, num2)
  160. longmul    ALLOC    ?LSIZE        Reserve space
  161.     CALL    ?10        Zero temp reg
  162.     TSA            Get stack address
  163.     LDI    ?LSIZE+2,S    Get source
  164.     PUSHA            Pass dest
  165.     PUSHI            Pass source
  166.     CALL    longcpy        Copy number
  167.     FREE    4        Release args
  168. ?14    LD    ?LSIZE+4,S    Get num1
  169.     PUSHA            Save it
  170.     CALL    longshr        Do the shift
  171.     LDI    S+        Clean stack
  172.     SJZ    ?15        No add
  173.     LDI    #Longreg    Point to temp
  174.     TSA            Get local
  175.     PUSHI            Pass dest
  176.     PUSHA            Pass source
  177.     CALL    longadd        Perform add
  178.     FREE    4        Release args
  179. ?15    LDI    ?LSIZE+4,S    Point to temp
  180.     CALL    ?50        Test for zero
  181.     SJZ    ?16        End, exit
  182.     TSA            Get local
  183.     PUSHA            Save it
  184.     CALL    longshl        Shift left
  185.     LD    S+        Clean stack
  186.     LEAI    0,S        Get local ptr
  187.     CALL    ?50        Zero?
  188.     SJNZ    ?14        Nope, keep going
  189. ?16    LD    ?LSIZE+4,S    Get num1 ptr
  190.     LDI    #Longreg    Point to dest
  191.     PUSHA            Pass dest
  192.     PUSHI            Pass source
  193.     CALL    longcpy        Copy it
  194.     FREE    ?LSIZE+4    Release args
  195.     RET
  196. * Divide two LONG numbers: longdiv(num1, num2)
  197. longdiv    CALL    ?10        Zero temp
  198.     LDB    #(?LSIZE*8)+1    Get count
  199.     PUSHA            Save for later
  200. ?17    CLR            Get zero
  201. ?18    STB    1,S        No carry in
  202.     LD    6,S        Get num1 ptr
  203.     PUSHA            Pass as parm
  204.     CALL    longshl        Shift it
  205.     LDI    S+        Get value back
  206.     PUSHA            Save new carry
  207.     LDB    I        Get low byte
  208.     OR    3,S        Include carry
  209.     STB    I        Resave
  210.     LDB    2,S        Get count
  211.     DEC            Reduce
  212.     STB    2,S        Resave
  213.     SJZ    ?19        End, exit
  214.     LD    #Longreg    Point to register
  215.     PUSHA            Pass as parm
  216.     CALL    longshl        Shift it
  217.     LDI    S+        Get address
  218.     LDB    I        Get Low byte
  219.     OR    S+        Include new carry
  220.     STB    I        Resave
  221.     LD    4,S        Get num2 pointer
  222.     PUSHI            Pass num1
  223.     PUSHA            Pass num2
  224.     CALL    longcmp        Do the compare
  225.     FREE    4        Release
  226.     SHR    #8        Test for > 1
  227.     SJNZ    ?17        Carry in zero
  228.     LD    #Longreg    Point to reg
  229.     LDI    4,S        Get num2 pointer
  230.     PUSHA            Pass longreg
  231.     PUSHI            Pass num2
  232.     CALL    longsub        Subtract
  233.     FREE    4        Release
  234.     LDB    #1        Get 1
  235.     SJMP    ?18        Carry in 1
  236. ?19    FREE    4        Clean stack
  237.     RET
  238.